import re
import time
from typing import List, Dict, Any
from .base_finance_query import BaseFinanceQuery

# 从core.logger导入get_logger函数
from ..core.logger import get_logger

# 使用get_logger函数初始化logger
logger = get_logger('agent.fund_queries')


class FundQueries(BaseFinanceQuery):
    """
    基金相关查询处理类
    处理所有与基金相关的复杂查询
    """
    
    def __init__(self):
        super().__init__()
    
    def handle_fund_scale_comparison(self, query: str) -> str:
        """
        处理基金规模比较查询
        
        Args:
            query: 查询文本
            
        Returns:
            查询结果
        """
        try:
            # 提取比较值
            value_match = re.search(r'(\d+(?:\.\d+)?)亿', query)
            if not value_match:
                return ""
            
            target_value = float(value_match.group(1))
            
            if "高于" in query:
                sql_query = """
                    SELECT 基金代码, 基金简称, [基金规模(亿元)] 
                    FROM 基金基本信息 
                    WHERE [基金规模(亿元)] > ? AND [基金规模(亿元)] IS NOT NULL
                    ORDER BY [基金规模(亿元)] DESC
                    LIMIT 10
                """
                comparison = "高于"
            else:
                sql_query = """
                    SELECT 基金代码, 基金简称, [基金规模(亿元)] 
                    FROM 基金基本信息 
                    WHERE [基金规模(亿元)] < ? AND [基金规模(亿元)] IS NOT NULL
                    ORDER BY [基金规模(亿元)] DESC
                    LIMIT 10
                """
                comparison = "低于"
            
            result = self._execute_query(sql_query, (target_value,))
            if result:
                result_lines = [f"基金规模{comparison}{target_value}亿元的基金有:"]
                for row in result:
                    result_lines.append(f"  {row['基金简称']}({row['基金代码']}): {row['基金规模(亿元)']}亿元")
                return "\n".join(result_lines)
            return ""
        except Exception as e:
            logger.error(f"处理基金规模比较查询出错: {e}")
            return ""
    
    def handle_holder_count_comparison(self, query: str) -> str:
        """
        处理基金持有人数量比较查询
        
        Args:
            query: 查询文本
            
        Returns:
            查询结果
        """
        try:
            # 提取比较值
            value_match = re.search(r'(\d+(?:\.\d+)?)万', query)
            if not value_match:
                return ""
            
            target_value = float(value_match.group(1))
            
            if "高于" in query:
                sql_query = """
                    SELECT 基金代码, [机构投资者持有份额(万份)]/[机构投资者持有份额占基金总份额比] as holders
                    FROM 基金持有人结构表 
                    WHERE [机构投资者持有份额(万份)] IS NOT NULL 
                    AND [机构投资者持有份额占基金总份额比] IS NOT NULL
                    AND [机构投资者持有份额占基金总份额比] > 0
                    AND [机构投资者持有份额(万份)]/[机构投资者持有份额占基金总份额比] > ?
                    ORDER BY [机构投资者持有份额(万份)]/[机构投资者持有份额占基金总份额比] DESC
                    LIMIT 10
                """
                comparison = "高于"
            else:
                sql_query = """
                    SELECT 基金代码, [机构投资者持有份额(万份)]/[机构投资者持有份额占基金总份额比] as holders
                    FROM 基金持有人结构表 
                    WHERE [机构投资者持有份额(万份)] IS NOT NULL 
                    AND [机构投资者持有份额占基金总份额比] IS NOT NULL
                    AND [机构投资者持有份额占基金总份额比] > 0
                    AND [机构投资者持有份额(万份)]/[机构投资者持有份额占基金总份额比] < ?
                    ORDER BY [机构投资者持有份额(万份)]/[机构投资者持有份额占基金总份额比] DESC
                    LIMIT 10
                """
                comparison = "低于"
            
            result = self._execute_query(sql_query, (target_value*10000,))
            if result:
                result_lines = [f"基金持有人数量{comparison}{target_value}万的基金有:"]
                for row in result:
                    holders_count = row['holders'] if row['holders'] else 0
                    result_lines.append(f"  {row['基金代码']}: 约{holders_count/10000:.2f}万人")
                return "\n".join(result_lines)
            return ""
        except Exception as e:
            logger.error(f"处理基金持有人数量比较查询出错: {e}")
            return ""
    
    def handle_extreme_value_query(self, query: str) -> str:
        """
        处理极值查询（最大、最小等）
        
        Args:
            query: 查询文本
            
        Returns:
            查询结果
        """
        try:
            if "基金" in query and "规模" in query:
                if "最大" in query or "最高" in query:
                    sql_query = """
                        SELECT 基金代码, 基金简称, [基金规模(亿元)] 
                        FROM 基金基本信息 
                        WHERE [基金规模(亿元)] IS NOT NULL
                        ORDER BY [基金规模(亿元)] DESC
                        LIMIT 5
                    """
                    extreme = "最大"
                elif "最小" in query or "最低" in query:
                    sql_query = """
                        SELECT 基金代码, 基金简称, [基金规模(亿元)] 
                        FROM 基金基本信息 
                        WHERE [基金规模(亿元)] IS NOT NULL
                        ORDER BY [基金规模(亿元)] ASC
                        LIMIT 5
                    """
                    extreme = "最小"
                else:
                    return ""
                
                result = self._execute_query(sql_query)
                if result:
                    result_lines = [f"基金规模{extreme}的基金有:"]
                    for row in result:
                        result_lines.append(f"  {row['基金简称']}({row['基金代码']}): {row['基金规模(亿元)']}亿元")
                    return "\n".join(result_lines)
            
            elif "基金" in query and "持有人" in query:
                if "最多" in query or "最大" in query or "最高" in query:
                    sql_query = """
                        SELECT 基金代码, [机构投资者持有份额(万份)]/[机构投资者持有份额占基金总份额比] as holders
                        FROM 基金持有人结构表 
                        WHERE [机构投资者持有份额(万份)] IS NOT NULL 
                        AND [机构投资者持有份额占基金总份额比] IS NOT NULL
                        AND [机构投资者持有份额占基金总份额比] > 0
                        ORDER BY [机构投资者持有份额(万份)]/[机构投资者持有份额占基金总份额比] DESC
                        LIMIT 5
                    """
                    extreme = "最多"
                elif "最少" in query or "最小" in query or "最低" in query:
                    sql_query = """
                        SELECT 基金代码, [机构投资者持有份额(万份)]/[机构投资者持有份额占基金总份额比] as holders
                        FROM 基金持有人结构表 
                        WHERE [机构投资者持有份额(万份)] IS NOT NULL 
                        AND [机构投资者持有份额占基金总份额比] IS NOT NULL
                        AND [机构投资者持有份额占基金总份额比] > 0
                        ORDER BY [机构投资者持有份额(万份)]/[机构投资者持有份额占基金总份额比] ASC
                        LIMIT 5
                    """
                    extreme = "最少"
                else:
                    return ""
                
                result = self._execute_query(sql_query)
                if result:
                    result_lines = [f"基金持有人数{extreme}的基金有:"]
                    for row in result:
                        holders_count = row['holders'] if row['holders'] else 0
                        result_lines.append(f"  {row['基金代码']}: 约{holders_count/10000:.2f}万人")
                    return "\n".join(result_lines)
            
            return ""
        except Exception as e:
            logger.error(f"处理极值查询出错: {e}")
            return ""
    
    def handle_aggregation_query(self, query: str) -> str:
        """
        处理聚合查询（平均、总和等）
        
        Args:
            query: 查询文本
            
        Returns:
            查询结果
        """
        try:
            if "托管费率" in query and "平均" in query:
                sql_query = "SELECT AVG(托管费率) as avg_rate FROM 基金基本信息 WHERE 托管费率 IS NOT NULL"
                result = self._execute_query(sql_query)
                if result and result[0]['avg_rate'] is not None:
                    avg_rate = result[0]['avg_rate']
                    return f"基金托管费率的平均值为: {avg_rate:.6f}"
            
            elif "基金" in query and "规模" in query and ("总和" in query or "合计" in query or "总计" in query):
                sql_query = "SELECT SUM([基金规模(亿元)]) as total_scale FROM 基金基本信息 WHERE [基金规模(亿元)] IS NOT NULL"
                result = self._execute_query(sql_query)
                if result and result[0]['total_scale'] is not None:
                    total_scale = result[0]['total_scale']
                    return f"所有基金的规模总和为: {total_scale:.2f}亿元"
            
            elif "管理费率" in query and "平均" in query:
                sql_query = "SELECT AVG(管理费率) as avg_rate FROM 基金基本信息 WHERE 管理费率 IS NOT NULL"
                result = self._execute_query(sql_query)
                if result and result[0]['avg_rate'] is not None:
                    avg_rate = result[0]['avg_rate']
                    return f"基金管理费率的平均值为: {avg_rate:.6f}"
            
            return ""
        except Exception as e:
            logger.error(f"处理聚合查询出错: {e}")
            return ""

    def count_funds_by_year(self, query: str) -> str:
        """
        统计某年成立的基金数量，支持指定基金管理公司
        
        Args:
            query: 查询字符串
            
        Returns:
            查询结果
        """
        try:
            # 提取基金管理公司
            fund_company_match = re.search(r'(.*?)在\d{4}年成立', query)
            if not fund_company_match:
                fund_company_match = re.search(r'(.*?)\d{4}年成立了多少基金', query)
            
            fund_company = None
            if fund_company_match:
                fund_company = fund_company_match.group(1).strip()
                # 处理常见的开头指令性词语
                for prefix in ['请查询', '查询', '我想知道', '请帮我查询']:
                    if fund_company.startswith(prefix):
                        fund_company = fund_company[len(prefix):].strip()
                        break
                # 移除可能的公司名称后缀
                company_suffixes = ['公司', '管理有限公司', '管理公司', '资产管理有限公司']
                for suffix in company_suffixes:
                    if fund_company.endswith(suffix):
                        fund_company = fund_company[:-len(suffix)].strip()
                        break
            
            # 提取年份
            year_match = re.search(r'(\d{4})年', query)
            if year_match:
                year = year_match.group(1)
            else:
                return "无法从查询中提取年份信息"
            
            # 查询指定年份成立的基金数量
            # 注意：成立日期字段格式为YYYYMMDD，使用LIKE ? || '%'来匹配年份前缀
            if fund_company:
                sql_query = """
                    SELECT COUNT(*) as count
                    FROM 基金基本信息 
                    WHERE 成立日期 LIKE ? || '%'
                    AND 管理人 LIKE ?
                """
                logger.info(f"执行SQL查询: {sql_query}")
                result = self._execute_query(sql_query, (f"{year}", f"%{fund_company}%"))
                
                if result and result[0]['count'] is not None:
                    count = result[0]['count']
                    return f"{fund_company}在{year}年成立的基金数量: {count}"
                else:
                    return f"未找到{fund_company}在{year}年成立的基金数据"
            else:
                # 不指定基金管理公司，查询所有基金
                sql_query = """
                    SELECT COUNT(*) as count
                    FROM 基金基本信息 
                    WHERE 成立日期 LIKE ? || '%'
                """
                logger.info(f"执行SQL查询: {sql_query}")
                result = self._execute_query(sql_query, (f"{year}",))
                
                if result and result[0]['count'] is not None:
                    count = result[0]['count']
                    return f"{year}年成立的基金数量: {count}"
                else:
                    return f"未找到{year}年成立的基金数据"
        except Exception as e:
            logger.error(f"统计某年成立的基金数量时出错: {e}")
            return f"查询执行出错: {str(e)}"
    
    def calculate_avg_custody_fee(self, query: str) -> str:
        """
        计算符合条件的基金托管费率的平均数
        
        Args:
            query: 查询字符串
            
        Returns:
            查询结果
        """
        start_time = time.time()
        logger.info(f"开始计算基金托管费率的平均数: {query}")
        try:
            # 提取基金管理公司、成立年份和托管人
            # 提取基金管理公司（优化正则表达式以排除开头的指令性词语）
            # 尝试直接提取公司名称模式：[公司名称]在[年份]年成立
            fund_company_match = re.search(r'(?:请列出)?(.*?)(?:基金管理有限公司|基金公司)在(\d{4})年成立', query)
            if fund_company_match:
                # 提取公司名称部分，如果有基金管理有限公司等后缀，添加回来
                company_name = fund_company_match.group(1).strip()
                if '基金管理有限公司' not in company_name and '基金公司' not in company_name:
                    # 检查是否已包含'基金'字样
                    if '基金' in company_name:
                        fund_company = company_name
                    else:
                        fund_company = company_name + '基金管理有限公司'
                else:
                    fund_company = company_name
                year = fund_company_match.group(2)
            else:
                # 备用方案：简单提取所有在'在[年份]年成立'之前的文本
                simple_match = re.search(r'(.*?)在(\d{4})年成立', query)
                if simple_match:
                    fund_company = simple_match.group(1).strip()
                    # 移除常见的开头指令性词语
                    for prefix in ['请列出', '列出', '查询', '找出']:
                        if fund_company.startswith(prefix):
                            fund_company = fund_company[len(prefix):].strip()
                            break
                    year = simple_match.group(2)
                else:
                    return "无法从查询中提取基金管理公司和成立年份信息"
            
            # 提取托管人（优化逻辑以支持更多格式和去除指令性词语）
            # 尝试多种可能的托管人提取模式
            patterns = [
                r'托管人为(.*?)的所有基金',  # 原始模式
                r'托管机构为(.*?)的所有基金',  # 替代说法
                r'托管人为(.*?)的基金',  # 简化说法
                r'托管机构为(.*?)的基金',  # 简化替代说法
                r'托管人为(.*?)$',  # 句尾匹配
                r'托管机构为(.*?)$',  # 句尾替代说法
            ]
            
            custodian = None
            for pattern in patterns:
                custodian_match = re.search(pattern, query)
                if custodian_match:
                    custodian = custodian_match.group(1).strip()
                    # 移除常见的开头指令性词语
                    for prefix in ['请列出', '列出', '查询', '找出']:
                        if custodian.startswith(prefix):
                            custodian = custodian[len(prefix):].strip()
                            break
                    # 移除可能的结束标记词
                    for suffix in ['的所有基金', '的基金']:
                        if custodian.endswith(suffix):
                            custodian = custodian[:-len(suffix)].strip()
                            break
                    break
            
            if not custodian:
                return "无法从查询中提取托管人信息"
            
            logger.info(f"查询条件: 基金管理公司='{fund_company}', 成立年份={year}, 托管人='{custodian}'")
            
            # 查询符合条件的托管费率的平均值
            # 注意：成立日期字段格式为YYYYMMDD，需要使用LIKE ? || '%'来匹配年份前缀
            sql_query = """
                SELECT AVG(CAST(REPLACE(托管费率, '%', '') AS REAL)) as avg_custody_fee
                FROM 基金基本信息
                WHERE 管理人 = ? AND 成立日期 LIKE ? || '%' AND 托管人 = ?
            """
            logger.info(f"执行SQL查询: {sql_query}")
            # 只传入年份字符串，SQLite会自动添加通配符进行前缀匹配
            result = self._execute_query(sql_query, (fund_company, f"{year}", custodian))
            
            if result and result[0]['avg_custody_fee'] is not None:
                avg_fee = float(result[0]['avg_custody_fee'])
                logger.info(f"查询成功完成，平均托管费率: {avg_fee:.4f}")
                # 确保正确格式化百分比，使用format方法避免f-string中的百分比格式化问题
                return "{}在{}年成立并且托管人为{}的所有基金的托管费率的平均数为: {:.2f}%".format(
                    fund_company, year, custodian, avg_fee)
            else:
                logger.warning("未找到符合条件的基金数据")
                return f"未找到{fund_company}在{year}年成立并且托管人为{custodian}的基金数据"
            
        except Exception as e:
            logger.error(f"计算托管费率平均数时出错: {e}")
            return f"查询执行出错: {str(e)}"
        finally:
            total_time = time.time() - start_time
            logger.info(f"计算基金托管费率平均数完成，总耗时: {total_time:.4f}秒")
    
    def find_fund_net_values(self, query: str) -> str:
        """
        查询基金在特定日期的资产净值和单位净值
        
        Args:
            query: 用户查询
            
        Returns:
            查询结果
        """
        try:
            # 提取基金代码和日期
            fund_code = self._extract_stock_code_from_query(query)
            date = self._extract_date_from_query(query)
            
            if not fund_code:
                return "无法从查询中提取基金代码"
            
            if not date:
                return "无法从查询中提取日期信息"
            
            # 查询基金在特定日期的净值信息
            net_value_query = """
            SELECT [单位净值], [资产净值]
            FROM 基金日行情表 
            WHERE 基金代码 = ? AND 交易日期 = ?
            """
            
            result = self._execute_query(net_value_query, (fund_code, date))
            
            if not result:
                return f"未找到基金代码为 {fund_code} 在 {date} 的净值信息"
            
            unit_net_value = result[0]['单位净值']
            net_asset_value = result[0]['资产净值']
            
            # 格式化结果
            result_str = f"基金 {fund_code} 在 {date} 的净值信息：\n"
            result_str += f"  单位净值: {unit_net_value} 元\n"
            result_str += f"  资产净值: {net_asset_value} 元"
            
            return result_str
            
        except Exception as e:
            logger.error(f"查询基金净值时出错: {e}")
            return f"查询执行出错: {str(e)}"
    
    def count_funds_with_increasing_shares(self, query: str) -> str:
        """
        统计基金期初份额小于期末份额的基金数量
        
        Args:
            query: 查询字符串
            
        Returns:
            查询结果
        """
        start_time = time.time()
        logger.info(f"开始统计基金期初份额小于期末份额的基金数量: {query}")
        try:
            # 提取基金管理公司和年份
            fund_company_match = re.search(r'(.*?)已发行的基金', query)
            if fund_company_match:
                fund_company = fund_company_match.group(1).strip()
                # 处理常见的开头指令性词语
                for prefix in ['请查询', '查询', '我想知道', '请帮我查询']:
                    if fund_company.startswith(prefix):
                        fund_company = fund_company[len(prefix):].strip()
                        break
            else:
                return "无法从查询中提取基金管理公司信息"
            
            # 提取年份
            year_match = re.search(r'(\d{4})年', query)
            if year_match:
                year = year_match.group(1)
            else:
                return "无法从查询中提取年份信息"
            
            # 修复基金管理公司名称提取问题，去除年份信息和开头的逗号
            fund_company = re.sub(r'在(\d{4})年', '', fund_company).strip()
            fund_company = fund_company.lstrip('，').strip()  # 去除开头的逗号
            
            logger.info(f"查询条件: 基金管理公司='{fund_company}', 年份={year}")
            
            # 查询符合条件的基金数量
            # 注意：日期字段格式为YYYYMMDD，需要使用LIKE ? || '%'来匹配年份前缀
            sql_query = """
                SELECT COUNT(*) as count
                FROM 基金规模变动表
                WHERE 基金代码 IN (
                    SELECT DISTINCT 基金代码
                    FROM 基金基本信息
                    WHERE 管理人 LIKE ?
                )
                AND 定期报告所属年度 = ?
                AND [报告期期初基金总份额] < [报告期期末基金总份额]
            """
            logger.info(f"执行SQL查询: {sql_query}")
            result = self._execute_query(sql_query, (f"%{fund_company}%", year))
            
            if result and result[0]['count'] is not None:
                count = result[0]['count']
                logger.info(f"查询成功完成，符合条件的基金数量: {count}")
                return f"{fund_company}在{year}年已发行的基金中，期初基金总份额小于期末基金总份额的基金数量为: {count}"
            else:
                logger.warning("未找到符合条件的基金数据")
                return f"未找到{fund_company}在{year}年已发行的基金中，期初基金总份额小于期末基金总份额的基金数据"
            
        except Exception as e:
            logger.error(f"统计基金期初份额小于期末份额的基金数量时出错: {e}")
            import traceback
            logger.error(f"错误详情: {traceback.format_exc()}")
            return f"查询执行出错: {str(e)}"
        finally:
            logger.info(f"统计基金期初份额小于期末份额的基金数量完成")

    def count_funds_with_more_personal_shares_in_money_market_type(self, query: str) -> str:
        """
        统计个人投资者持有份额大于机构投资者持有份额的货币型基金数量
        
        Args:
            query: 用户查询
            
        Returns:
            查询结果
        """
        try:
            def _query(cursor):
                # 查询个人投资者持有份额大于机构投资者持有份额的货币型基金数量
                sql_query = """
                SELECT COUNT(*) as count
                FROM 基金份额持有人结构 f
                JOIN 基金基本信息 b ON f.基金代码 = b.基金代码
                WHERE b.基金类型 = '货币型' 
                AND CAST(f.个人投资者持有的基金份额 AS REAL) > CAST(f.机构投资者持有的基金份额 AS REAL)
                """
                
                logger.info(f"执行SQL查询: {sql_query}")
                cursor.execute(sql_query)
                result = cursor.fetchone()
                
                if result and result['count']:
                    count = result['count']
                    logger.info(f"查询成功完成，符合条件的货币型基金数量: {count}")
                    return f"个人投资者持有份额大于机构投资者持有份额的货币型基金共有 {count} 只"
                else:
                    logger.warning("查询未返回有效结果")
                    return "未找到符合条件的货币型基金"
            
            return self._execute_query_with_db(_query)
            
        except Exception as e:
            logger.error(f"统计个人投资者持有份额大于机构投资者的货币型基金数量时出错: {e}")
            return f"查询执行出错: {str(e)}"
    
    def count_funds_with_more_personal_shares_in_stock_type(self, query: str) -> str:
        """
        统计个人投资者持有份额大于机构投资者持有份额且属于股票型类型的基金数量
        
        Args:
            query: 用户查询
            
        Returns:
            查询结果
        """
        try:
            def _query(cursor):
                # 查询个人投资者持有份额大于机构投资者持有份额且属于股票型类型的基金数量
                sql_query = """
                SELECT COUNT(*) as count
                FROM 基金份额持有人结构 f
                JOIN 基金基本信息 b ON f.基金代码 = b.基金代码
                WHERE b.基金类型 = '股票型' 
                AND CAST(f.个人投资者持有的基金份额 AS REAL) > CAST(f.机构投资者持有的基金份额 AS REAL)
                """
                
                logger.info(f"执行SQL查询: {sql_query}")
                cursor.execute(sql_query)
                result = cursor.fetchone()
                
                if result and result['count']:
                    count = result['count']
                    logger.info(f"查询成功完成，符合条件的股票型基金数量: {count}")
                    return f"个人投资者持有份额大于机构投资者持有份额且属于股票型类型的基金共有 {count} 只"
                else:
                    logger.warning("查询未返回有效结果")
                    return "未找到符合条件的股票型基金"
            
            return self._execute_query_with_db(_query)
            
        except Exception as e:
            logger.error(f"统计个人投资者持有份额大于机构投资者的股票型基金数量时出错: {e}")
            return f"查询执行出错: {str(e)}"
    
    def count_funds_with_more_personal_shares_in_bond_type(self, query: str) -> str:
        """
        统计个人投资者持有份额大于机构投资者持有份额且属于债券型类型的基金数量
        
        Args:
            query: 用户查询
            
        Returns:
            查询结果
        """
        try:
            def _query(cursor):
                # 查询个人投资者持有份额大于机构投资者持有份额且属于债券型类型的基金数量
                sql_query = """
                SELECT COUNT(*) as count
                FROM 基金份额持有人结构 f
                JOIN 基金基本信息 b ON f.基金代码 = b.基金代码
                WHERE b.基金类型 = '债券型' 
                AND CAST(f.个人投资者持有的基金份额 AS REAL) > CAST(f.机构投资者持有的基金份额 AS REAL)
                """
                
                logger.info(f"执行SQL查询: {sql_query}")
                cursor.execute(sql_query)
                result = cursor.fetchone()
                
                if result and result['count']:
                    count = result['count']
                    logger.info(f"查询成功完成，符合条件的债券型基金数量: {count}")
                    return f"个人投资者持有份额大于机构投资者持有份额且属于债券型类型的基金共有 {count} 只"
                else:
                    logger.warning("查询未返回有效结果")
                    return "未找到符合条件的债券型基金"
            
            return self._execute_query_with_db(_query)
            
        except Exception as e:
            logger.error(f"统计个人投资者持有份额大于机构投资者的债券型基金数量时出错: {e}")
            return f"查询执行出错: {str(e)}"
            
    def count_funds_with_more_personal_shares_in_other_type(self, query: str) -> str:
        """
        统计个人投资者持有份额大于机构投资者持有份额且属于其他型类型的基金数量
        
        Args:
            query: 用户查询
            
        Returns:
            查询结果
        """
        try:
            def _query(cursor):
                # 查询个人投资者持有份额大于机构投资者持有份额且属于其他型类型的基金数量
                sql_query = """
                SELECT COUNT(*) as count
                FROM 基金份额持有人结构 f
                JOIN 基金基本信息 b ON f.基金代码 = b.基金代码
                WHERE b.基金类型 = '其他型' 
                AND CAST(f.个人投资者持有的基金份额 AS REAL) > CAST(f.机构投资者持有的基金份额 AS REAL)
                """
                
                logger.info(f"执行SQL查询: {sql_query}")
                cursor.execute(sql_query)
                result = cursor.fetchone()
                
                if result and result['count']:
                    count = result['count']
                    logger.info(f"查询成功完成，符合条件的其他型基金数量: {count}")
                    return f"个人投资者持有份额大于机构投资者持有份额且属于其他型类型的基金共有 {count} 只"
                else:
                    logger.warning("查询未返回有效结果")
                    return "未找到符合条件的其他型基金"
            
            return self._execute_query_with_db(_query)
            
        except Exception as e:
            logger.error(f"统计个人投资者持有份额大于机构投资者的其他型基金数量时出错: {e}")
            return f"查询执行出错: {str(e)}"
            
    def count_funds_with_more_personal_shares_in_mixed_type(self, query: str) -> str:
        """
        统计个人投资者持有份额大于机构投资者持有份额且属于混合型类型的基金数量
        
        Args:
            query: 用户查询
            
        Returns:
            查询结果
        """
        try:
            def _query(cursor):
                # 查询个人投资者持有份额大于机构投资者持有份额且属于混合型类型的基金数量
                sql_query = """
                SELECT COUNT(*) as count
                FROM 基金份额持有人结构 f
                JOIN 基金基本信息 b ON f.基金代码 = b.基金代码
                WHERE b.基金类型 = '混合型' 
                AND CAST(f.个人投资者持有的基金份额 AS REAL) > CAST(f.机构投资者持有的基金份额 AS REAL)
                """
                
                logger.info(f"执行SQL查询: {sql_query}")
                cursor.execute(sql_query)
                result = cursor.fetchone()
                
                if result and result['count']:
                    count = result['count']
                    logger.info(f"查询成功完成，符合条件的混合型基金数量: {count}")
                    return f"个人投资者持有份额大于机构投资者持有份额且属于混合型类型的基金共有 {count} 只"
                else:
                    logger.warning("查询未返回有效结果")
                    return "未找到符合条件的混合型基金"
            
            return self._execute_query_with_db(_query)
            
        except Exception as e:
            logger.error(f"统计个人投资者持有份额大于机构投资者的混合型基金数量时出错: {e}")
            return f"查询执行出错: {str(e)}"
    
    def _extract_date_from_query(self, query: str) -> str:
        """
        从查询中提取日期
        
        Args:
            query: 查询字符串
            
        Returns:
            日期字符串，格式为YYYYMMDD
        """
        # 匹配 YYYYMMDD 格式的日期
        date_patterns = [
            r'(20\d{6})',  # 标准格式
            r'在(20\d{6})[日|日期]',  # 在YYYYMMDD日格式
            r'(20\d{4})日',  # YYYYMMDD格式
        ]
        
        for pattern in date_patterns:
            match = re.search(pattern, query)
            if match:
                date_str = match.group(1)
                return date_str
        
        # 匹配中文格式日期
        cn_date_match = re.search(r'(20\d{2})年(\d{1,2})月(\d{1,2})日', query)
        if cn_date_match:
            year = cn_date_match.group(1)
            month = cn_date_match.group(2).zfill(2)
            day = cn_date_match.group(3).zfill(2)
            return f"{year}{month}{day}"
        
        return ""
    
    def count_funds_with_management_fee_less_than(self, query: str) -> str:
        """
        统计基金管理公司在特定年份成立的管理费率小于特定值的基金数量
        
        Args:
            query: 查询字符串
            
        Returns:
            查询结果
        """
        try:
            # 提取基金管理公司
            fund_company_match = re.search(r'(.*?)在\d{4}年成立', query)
            if not fund_company_match:
                fund_company_match = re.search(r'(.*?)管理的基金', query)
                if not fund_company_match:
                    # 尝试直接匹配公司名称模式
                    fund_company_match = re.search(r'([^在]+?)在\d{4}年', query)
                         
            if fund_company_match:
                fund_company = fund_company_match.group(1).strip()
                # 处理常见的开头指令性词语
                for prefix in ['请查询', '查询', '我想知道', '请帮我查询']:
                    if fund_company.startswith(prefix):
                        fund_company = fund_company[len(prefix):].strip()
                        break
                # 移除可能的公司名称后缀
                company_suffixes = ['公司', '管理有限公司', '管理公司', '资产管理有限公司']
                for suffix in company_suffixes:
                    if fund_company.endswith(suffix):
                        fund_company = fund_company[:-len(suffix)].strip()
                        break
            else:
                return "无法从查询中提取基金管理公司信息"
            
            # 提取成立年份
            year_match = re.search(r'(\d{4})年成立', query)
            if not year_match:
                year_match = re.search(r'(\d{4})年', query)
                
            if year_match:
                year = year_match.group(1)
            else:
                return "无法从查询中提取成立年份信息"
            
            # 提取管理费率条件
            fee_rate_match = re.search(r'管理费率小于(\d+(?:\.\d+)?)%', query)
            if not fee_rate_match:
                fee_rate_match = re.search(r'管理费率小于(\d+(?:\.\d+)?)', query)
                
            if fee_rate_match:
                fee_rate = float(fee_rate_match.group(1))
            else:
                return "无法从查询中提取管理费率条件"
            
            logger.info(f"查询条件: 基金管理公司='{fund_company}', 成立年份={year}, 管理费率<{fee_rate}%")
            
            # 执行SQL查询
            sql_query = """
                SELECT COUNT(*) as count
                FROM 基金基本信息
                WHERE 管理人 LIKE ?
                AND 成立日期 LIKE ? || '%'
                AND CAST(REPLACE(管理费率, '%', '') AS REAL) < ?
            """
            
            result = self._execute_query(sql_query, (f"%{fund_company}%", year, fee_rate))
            
            if result and result[0]['count'] is not None:
                count = result[0]['count']
                logger.info(f"查询成功完成，符合条件的基金数量: {count}")
                return f"{fund_company}在{year}年成立的管理费率小于{fee_rate}%的基金共有{count}只"
            else:
                logger.warning("未找到符合条件的基金数据")
                return f"未找到{fund_company}在{year}年成立的管理费率小于{fee_rate}%的基金数据"
            
        except Exception as e:
            logger.error(f"处理基金管理费率查询时出错: {e}")
            return f"查询执行出错: {str(e)}"
    
    def _extract_stock_code_from_query(self, query: str) -> str:
        """
        从查询中提取股票代码
        
        Args:
            query: 查询字符串
            
        Returns:
            股票代码
        """
        # 匹配6位数字的股票代码
        stock_code_patterns = [
            r'(\d{6})股票',
            r'股票(\d{6})',
            r'代码为(\d{6})',
            r'(\d{6})代码',
            r'(\d{6})',
        ]
        
        for pattern in stock_code_patterns:
            match = re.search(pattern, query)
            if match:
                return match.group(1)
        
        return ""
    
    def count_funds_with_more_institutional_shares(self, query: str) -> str:
        """
        统计基金中机构投资者持有份额大于个人投资者的基金数量
        
        Args:
            query: 查询字符串
            
        Returns:
            查询结果
        """
        start_time = time.time()
        logger.info("开始统计基金中机构投资者持有份额大于个人投资者的基金数量")
        logger.debug(f"查询内容: {query}")
        
        try:
            # 提取基金管理公司
            fund_company_match = re.search(r'(.*?)管理的基金', query)
            if fund_company_match:
                fund_company = fund_company_match.group(1).strip()
                # 处理常见的开头指令性词语
                for prefix in ['请查询', '查询', '我想知道', '请帮我查询']:
                    if fund_company.startswith(prefix):
                        fund_company = fund_company[len(prefix):].strip()
                        break
            else:
                logger.warning("无法从查询中提取基金管理公司信息")
                return "无法从查询中提取基金管理公司信息"
            
            logger.info(f"查询条件: 基金管理公司='{fund_company}'")
            
            # 连接数据库
            conn = sqlite3.connect(self.db_path)
            conn.row_factory = sqlite3.Row
            cursor = conn.cursor()
            
            # 查询基金中机构投资者持有份额大于个人投资者的基金数量
            sql_query = """
                SELECT COUNT(*) as count
                FROM 基金基本信息 a
                JOIN 基金份额持有人结构 b ON a.基金代码 = b.基金代码
                WHERE a.管理人 LIKE ?
                AND CAST(REPLACE(b.机构投资者持有的基金份额占总份额比例, '%', '') AS REAL) > 
                    CAST(REPLACE(b.个人投资者持有的基金份额占总份额比例, '%', '') AS REAL)
            """
            
            logger.info("执行SQL查询基金中机构投资者持有份额大于个人投资者的基金数量")
            logger.info(f"SQL语句: {sql_query}")
            logger.info(f"查询参数: 管理人 LIKE '%{fund_company}%'")
            
            cursor.execute(sql_query, (f"%{fund_company}%",))
            result = cursor.fetchone()
            
            if result and result['count'] is not None:
                count = result[0]['count']
                logger.info(f"查询成功完成，符合条件的基金数量: {count}")
                return f"在{fund_company}管理的基金中，有{count}只基金的机构投资者持有份额大于个人投资者"
            else:
                logger.warning("未找到符合条件的基金数据")
                return f"未找到{fund_company}管理的基金中机构投资者持有份额大于个人投资者的数据"
            
        except Exception as e:
            logger.error(f"统计基金中机构投资者持有份额大于个人投资者的基金数量时出错: {e}")
            return f"查询执行出错: {str(e)}"
        finally:
            if 'conn' in locals():
                conn.close()
            exec_time = time.time() - start_time
            logger.info(f"统计基金中机构投资者持有份额大于个人投资者的基金数量完成，耗时: {exec_time:.4f}秒")

    def count_funds_by_year_and_type(self, query: str) -> str:
        """
        统计某年成立的特定类型基金数量，支持指定基金管理公司
        
        Args:
            query: 查询字符串
            
        Returns:
            查询结果
        """
        try:
            # 提取基金管理公司
            fund_company_match = re.search(r'(.*?)在\d{4}年成立', query)
            if not fund_company_match:
                fund_company_match = re.search(r'(.*?)\d{4}年成立了多少.*基金', query)
            
            fund_company = None
            if fund_company_match:
                fund_company = fund_company_match.group(1).strip()
                # 处理常见的开头指令性词语
                for prefix in ['请查询', '查询', '我想知道', '请帮我查询', '我想了解一下']:
                    if fund_company.startswith(prefix):
                        fund_company = fund_company[len(prefix):].strip()
                        break
                # 移除可能的公司名称后缀
                company_suffixes = ['公司', '管理有限公司', '管理公司', '资产管理有限公司']
                for suffix in company_suffixes:
                    if fund_company.endswith(suffix):
                        fund_company = fund_company[:-len(suffix)].strip()
                        break
            
            # 提取年份
            year_match = re.search(r'(\d{4})年', query)
            if year_match:
                year = year_match.group(1)
            else:
                return "无法从查询中提取年份信息"
            
            # 提取基金类型
            fund_type = ""
            if "债券型" in query:
                fund_type = "债券型"
            elif "股票型" in query:
                fund_type = "股票型"
            elif "混合型" in query:
                fund_type = "混合型"
            elif "货币型" in query:
                fund_type = "货币型"
            
            # 查询指定年份成立的基金数量
            # 注意：成立日期字段格式为YYYYMMDD，使用LIKE ? || '%'来匹配年份前缀
            if fund_company:
                sql_query = """
                    SELECT COUNT(*) as count
                    FROM 基金基本信息 
                    WHERE 成立日期 LIKE ? || '%'
                    AND 管理人 LIKE ?
                    AND 基金类型 = ?
                """
                logger.info(f"执行SQL查询: {sql_query}")
                result = self._execute_query(sql_query, (f"{year}", f"%{fund_company}%", fund_type))
                
                if result and result[0]['count'] is not None:
                    count = result[0]['count']
                    return f"{fund_company}在{year}年成立的{fund_type}基金数量: {count}"
                else:
                    return f"未找到{fund_company}在{year}年成立的{fund_type}基金数据"
            else:
                # 不指定基金管理公司，查询所有基金
                sql_query = """
                    SELECT COUNT(*) as count
                    FROM 基金基本信息 
                    WHERE 成立日期 LIKE ? || '%'
                    AND 基金类型 = ?
                """
                logger.info(f"执行SQL查询: {sql_query}")
                result = self._execute_query(sql_query, (f"{year}", fund_type))
                
                if result and result[0]['count'] is not None:
                    count = result[0]['count']
                    return f"{year}年成立的{fund_type}基金数量: {count}"
                else:
                    return f"未找到{year}年成立的{fund_type}基金数据"
        except Exception as e:
            logger.error(f"统计某年成立的特定类型基金数量时出错: {e}")
            return f"查询执行出错: {str(e)}"
